package com.ngu.util;

import java.util.Optional;
import java.util.function.Consumer;

/**
 * @description: lambda学习类
 * @author: hsj
 * @create: 2020-02-29 16:29
 **/
public class LambdaClass {

    public static void main(String[] args) throws Exception {

//        OptionalTestApi("华强");
          ConsumerTestApi();

//        List<String> list = Arrays.asList("11,北京","22,上海","33,广州","44,深圳");
//        List<String > conString = list.parallelStream().map(s -> s.split(",")[1]).collect(Collectors.toList());
//        conString = conString.parallelStream().filter(s -> s.equals("深圳")).collect(Collectors.toList());
//        System.out.println(conString);
//        List<Integer> co = list.stream().map(s -> s.split(",")[0]).map(Integer::parseInt).filter(s -> s > 10).collect(Collectors.toList());
//        System.out.println(co);
//
//        /**
//         * 通过stream流改造后的list为[22,33,44]
//         */
//        List<Integer> collect = list.stream().map(s -> s.split(",")[0]).
//                map(Integer::parseInt).filter(s -> s > 20).collect(Collectors.toList());


        /**
         * 通过parallelStream(并发流), 效率会更高
         */
//        List<Integer> collect1 = list.parallelStream().map(s -> s.split(",")[0]).
//                map(Integer::parseInt).filter(s -> s > 20).collect(Collectors.toList());
    }

    /**
     * 用于简化Java中对空值的判断处理，以防止出现各种空指针异常。
     * Optional实际上是对一个变量进行封装，它包含有一个属性value，实际上就是这个变量的值。
     */
    public static void OptionalTestApi(String value) throws Exception {
        Optional<String> s = Optional.ofNullable(value);
        s.ifPresent(System.out::println);
        //当传入的对象为null时，orElse会展现设置值.不为null时展现原值
        System.out.println("orElse表达式：" + s.orElse("ss"));
        //变量为null时抛出异常
        System.out.println("orElseThrow()表达式:" + s.orElseThrow(() -> new Exception("变量为null!")));
    }


    /**
     * Consumer是一个函数式编程接口； 顾名思义，Consumer的意思就是消费，即针对某个东西我们来使用它，因此它包含有一个有输入而无输出的accept接口方法；
     * 除accept方法，它还包含有andThen这个方法；
     */
    public static void ConsumerTestApi() {
        //接口Consumer
        Consumer f = System.out::println;
        Consumer f2 = n -> System.out.println(n + "-f2");
        f.accept("testConsumer");
        //调一次f，再调一次f2  。执行完F后再执行F2的Accept方法
        f.andThen(f2).accept("testConsumer");
        //连续执行F的Accept方法
        f.andThen(f).andThen(f).andThen(f2).accept("test2");
    }



}
